package org.Yiran.timetale_re.energy.power;

import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.energy.IEnergyStorage;
import org.Yiran.timetale_re.energy.BaseEnergyStorage;

/**
 * Forge Energy(FE) 电力存储系统
 * <p>
 * 继承自 BaseEnergyStorage，专门处理 Forge Energy 单位。
 * 提供了完整的能量存储和传输功能，包括接收、提取、传输等操作。
 * </p>
 */
public class ForgeEnergyStorage extends BaseEnergyStorage {
    
    // ============================== 构造方法 ==============================
    
    /**
     * 构造函数 - 指定容量
     * 
     * @param capacity 容量（FE单位）
     */
    public ForgeEnergyStorage(int capacity) {
        super(capacity);
    }

    /**
     * 构造函数 - 指定容量和最大传输速率
     * 
     * @param capacity 容量（FE单位）
     * @param maxTransfer 最大传输速率（FE/tick）
     */
    public ForgeEnergyStorage(int capacity, int maxTransfer) {
        super(capacity, maxTransfer);
    }

    /**
     * 构造函数 - 分别指定接收和提取的最大速率
     * 
     * @param capacity 容量（FE单位）
     * @param maxReceive 最大接收速率（FE/tick）
     * @param maxExtract 最大提取速率（FE/tick）
     */
    public ForgeEnergyStorage(int capacity, int maxReceive, int maxExtract) {
        super(capacity, maxReceive, maxExtract);
    }

    /**
     * 构造函数 - 完整参数
     * 
     * @param capacity 容量（FE单位）
     * @param maxReceive 最大接收速率（FE/tick）
     * @param maxExtract 最大提取速率（FE/tick）
     * @param initialEnergy 初始能量（FE单位）
     */
    public ForgeEnergyStorage(int capacity, int maxReceive, int maxExtract, int initialEnergy) {
        super(capacity, maxReceive, maxExtract, initialEnergy);
    }
    
    // ============================== 基础能量操作方法 ==============================
    
    /**
     * 获取当前存储的能量
     * 
     * @return 当前能量值（FE）
     */
    public int getEnergy() {
        return getEnergyStored();
    }

    /**
     * 获取最大能量容量
     * 
     * @return 最大容量（FE）
     */
    public int getCapacity() {
        return getMaxEnergyStored();
    }

    /**
     * 接收能量
     * 
     * @param maxReceive 最大接收量（FE）
     * @param simulate 是否为模拟操作
     * @return 实际接收的能量（FE）
     */
    public int receiveEnergyFE(int maxReceive, boolean simulate) {
        return receiveEnergy(maxReceive, simulate);
    }

    /**
     * 提取能量
     * 
     * @param maxExtract 最大提取量（FE）
     * @param simulate 是否为模拟操作
     * @return 实际提取的能量（FE）
     */
    public int extractEnergyFE(int maxExtract, boolean simulate) {
        return extractEnergy(maxExtract, simulate);
    }

    /**
     * 检查是否可以提取能量
     * 
     * @return 是否可以提取
     */
    public boolean isExtractable() {
        return canExtract();
    }

    /**
     * 检查是否可以接收能量
     * 
     * @return 是否可以接收
     */
    public boolean isReceivable() {
        return canReceive();
    }
    
    // ============================== 高级能量操作方法 ==============================
    
    /**
     * 获取能量百分比
     * 
     * @return 能量百分比（0.0 - 1.0）
     */
    public double getEnergyPercentage() {
        if (capacity <= 0) {
            return 0.0;
        }
        return (double) energy / capacity;
    }

    /**
     * 向其他Forge Energy存储传输能量
     * <p>
     * 从当前存储中提取能量并传输到目标存储中
     * </p>
     * 
     * @param energyStorage 目标能量存储
     * @param maxExtract 最大提取量（FE）
     * @param simulate 是否为模拟操作
     * @return 实际传输的能量（FE）
     */
    public int extractEnergyToFEStorage(LazyOptional<IEnergyStorage> energyStorage, int maxExtract, boolean simulate) {
        if (!energyStorage.isPresent()) {
            return 0;
        }

        return energyStorage.map(storage -> {
            if (storage.canReceive()) {
                return this.extractEnergy(maxExtract, simulate);
            }
            return 0;
        }).orElse(0);
    }

    /**
     * 从其他Forge Energy存储接收能量
     * <p>
     * 从源存储中提取能量并存储到当前存储中
     * </p>
     * 
     * @param energyStorage 源能量存储
     * @param maxReceive 最大接收量（FE）
     * @param simulate 是否为模拟操作
     * @return 实际接收的能量（FE）
     */
    public int receiveEnergyFromFEStorage(LazyOptional<IEnergyStorage> energyStorage, int maxReceive, boolean simulate) {
        if (!energyStorage.isPresent()) {
            return 0;
        }

        return energyStorage.map(storage -> {
            if (storage.canExtract()) {
                return storage.extractEnergy(maxReceive, simulate);
            }
            return 0;
        }).orElse(0);
    }
    
    // ============================== 显示相关方法 ==============================
    
    /**
     * 获取Forge Energy的推荐显示颜色
     * 
     * @return 颜色值（ARGB格式）
     */
    public int getEnergyDisplayColor() {
        // 蓝色: 0xFF0000FF (ARGB格式)
        return 0xFF5555FF;
    }

    /**
     * 获取Forge Energy的RGB颜色值
     * 
     * @return RGB颜色值
     */
    public int getEnergyColorRGB() {
        // 返回蓝色的RGB值
        return 0x5555FF;
    }
}